﻿#define _CRT_SECURE_NO_WARNINGS 1




/*
* 卡拉兹(Callatz)猜想：

对任何一个正整数 n，如果它是偶数，那么把它砍掉一半；如果它是奇数，那么把 (3n+1) 砍掉一半。
这样一直反复砍下去，最后一定在某一步得到 n=1。
卡拉兹在 1950 年的世界数学家大会上公布了这个猜想，传说当时耶鲁大学师生齐动员，
拼命想证明这个貌似很傻很天真的命题，结果闹得学生们无心学业，一心只证 (3n+1)，
以至于有人说这是一个阴谋，卡拉兹是在蓄意延缓美国数学界教学与科研的进展……

我们今天的题目不是证明卡拉兹猜想，而是对给定的任一不超过 1000 的正整数 n，简单地数一下，
需要多少步（砍几下）才能得到 n=1？

输入格式：
每个测试输入包含 1 个测试用例，即给出正整数 n 的值。

输出格式：
输出从 n 计算到 1 需要的步数。

输入样例：
3
输出样例：
5
*/

//#include<stdio.h>
//int main()
//{
//    int n = 0;
//    int count = 0;
//    if (scanf("%d", &n) != 1)
//    {
//        printf("Invalid input\n");
//        return 1;
//    }
//    while (n != 1)
//    {
//        if (n % 2 == 0)
//        {
//            n = n / 2;
//        }
//        else
//        {
//            n = (3 * n + 1) / 2;
//        }
//        count++;
//    }
//    printf("%d\n", count);
//    return 0;
//}





#include <stdio.h>
#include <string.h>


/*
*读入一个正整数 n，计算其各位数字之和，用汉语拼音写出和的每一位数字。

输入格式：
每个测试输入包含 1 个测试用例，即给出自然数 n 的值。这里保证 n 小于 10的100次方
输出格式：
在一行内输出 n 的各位数字之和的每一位，拼音数字间有 1 空格，但一行中最后一个拼音数字后没有空格。
输入样例：
1234567890987654321123456789
输出样例：
yi san wu
*/

//int main() {
//    char n[101]; // 存储输入的数字字符串，最多100位+1个结束符
//    scanf("%s", n);
//
//    // 计算各位数字之和
//    int sum = 0;
//    for (int i = 0; n[i] != '\0'; i++) 
//    {
//        sum += n[i] - '0'; // 将字符转换为数字并累加
//    }
//
//    // 数字到拼音的映射
//    const char* pinyin[] = 
//    {
//        "ling", "yi", "er", "san", "si",
//        "wu", "liu", "qi", "ba", "jiu"
//    };
//
//    // 将和转换为字符串以便逐位处理
//    char sum_str[20]; // 足够大的空间存储和的字符串表示
//    sprintf(sum_str, "%d", sum);
//
//    // 输出拼音
//    int len = strlen(sum_str);
//    for (int i = 0; i < len; i++) 
//    {
//        int digit = sum_str[i] - '0';
//        printf("%s", pinyin[digit]);
//
//        // 如果不是最后一个数字，输出空格
//        if (i != len - 1) {
//            printf(" ");
//        }
//    }
//
//    return 0;
//}




/*
* 
 “答案正确”是自动判题系统给出的最令人欢喜的回复。本题属于 PAT 的“答案正确”大派送 —— 只要读入的字符串满足下列条件，系统就输出“答案正确”，否则输出“答案错误”。

得到“答案正确”的条件是：

字符串中必须仅有 P、 A、 T这三种字符，不可以包含其它字符；
任意形如 xPATx 的字符串都可以获得“答案正确”，其中 x 或者是空字符串，或者是仅由字母 A 组成的字符串；
如果 aPbTc 是正确的，那么 aPbATca 也是正确的，其中 a、 b、 c 均或者是空字符串，或者是仅由字母 A 组成的字符串。
现在就请你为 PAT 写一个自动裁判程序，判定哪些字符串是可以获得“答案正确”的。

输入格式：
每个测试输入包含 1 个测试用例。第 1 行给出一个正整数 n (≤10)，是需要检测的字符串个数。接下来每个字符串占一行，字符串长度不超过 100，且不包含空格。

输出格式：
每个字符串的检测结果占一行，如果该字符串可以获得“答案正确”，则输出 YES，否则输出 NO。

输入样例：
10
PAT
PAAT
AAPATAA
AAPAATAAAA
xPATx
PT
Whatever
APAAATAA
APT
APATTAA

输出样例：
YES
YES
YES
YES
NO
NO
NO
NO
NO
NO
*/
#include <stdio.h>
#include <string.h>
#include <stdbool.h>

//bool isOnlyPAT(const char* str) 
//{
//    for (int i = 0; str[i] != '\0'; i++) 
//    {
//        if (str[i] != 'P' && str[i] != 'A' && str[i] != 'T') {
//            return false;
//        }
//    }
//    return true;
//}
//
//bool isCorrect(const char* str) 
//{
//    if (!isOnlyPAT(str)) return false;
//
//    int len = strlen(str);
//    int p_pos = -1, t_pos = -1;
//
//    // 定位P和T的位置
//    for (int i = 0; i < len; i++) 
//    {
//        if (str[i] == 'P') 
//        {
//            if (p_pos != -1) return false; // 多个P
//            p_pos = i;
//        }
//        else if (str[i] == 'T') 
//        {
//            if (t_pos != -1) return false; // 多个T
//            t_pos = i;
//        }
//    }
//
//    // 检查P和T是否存在且P在T前
//    if (p_pos == -1 || t_pos == -1 || p_pos >= t_pos) 
//    {
//        return false;
//    }
//
//    // 检查中间是否有至少一个A
//    if (t_pos - p_pos <= 1) 
//    {
//        return false;
//    }
//
//    int a_before = p_pos;
//    int a_middle = t_pos - p_pos - 1;
//    int a_after = len - t_pos - 1;
//
//    // 基础情况：xPATx
//    if (a_middle == 1 && a_before == a_after) 
//    {
//        return true;
//    }
//
//    // 递归情况：检查是否可以由更短的正确字符串推导而来
//    if (a_after >= a_before && a_middle >= 1) 
//    {
//        // 构造更短的字符串
//        char shorter[101] = { 0 };
//        strncpy(shorter, str, p_pos + 1); // 复制到P
//        strncat(shorter, str + p_pos + 1, a_middle - 1); // 少一个A
//        strcat(shorter, "T"); // 添加T
//        strncat(shorter, str + t_pos + 1, a_after - a_before); // 减少a_before个A
//
//        return isCorrect(shorter);
//    }
//
//    return false;
//}
//
//int main() 
//{
//    int n;
//    scanf("%d", &n);
//    while (n--) {
//        char str[101];
//        scanf("%s", str);
//        printf("%s\n", isCorrect(str) ? "YES" : "NO");
//    }
//    return 0;
//}

/*
* 读入 n（>0）名学生的姓名、学号、成绩，分别输出成绩最高和成绩最低学生的姓名和学号。

输入格式：
每个测试输入包含 1 个测试用例，格式为

第 1 行：正整数 n
第 2 行：第 1 个学生的姓名 学号 成绩
第 3 行：第 2 个学生的姓名 学号 成绩
  ... ... ...
第 n+1 行：第 n 个学生的姓名 学号 成绩
其中姓名和学号均为不超过 10 个字符的字符串，成绩为 0 到 100 之间的一个整数，这里保证在一组测试用例中没有两个学生的成绩是相同的。

输出格式：
对每个测试用例输出 2 行，第 1 行是成绩最高学生的姓名和学号，第 2 行是成绩最低学生的姓名和学号，字符串间有 1 空格。

输入样例：
3
Joe Math990112 89
Mike CS991301 100
Mary EE990830 95
输出样例：
Mike CS991301
Joe Math990112
*/


#include<stdio.h>
#include<string.h>

//struct Student
//{
//    char name[11];
//    char id[11];
//    int score;
//};
//
//int main()
//{
//    int n;
//    scanf("%d", &n);
//    struct Student students[n];
//    struct Student max_stu, min_stu;
//    int max_score = -1;
//    int min_score = 101;
//
//    for (int i = 0; i < n; i++)
//    {
//        scanf("%s %s %d", students[i].name, students[i].id, &students[i].score);
//
//        if (students[i].score > max_score)
//        {
//            max_score = students[i].score;
//            max_stu = students[i];
//        }
//        if (students[i].score < min_score)
//        {
//            min_score = students[i].score;
//            min_stu = students[i];
//        }
//    }
//    printf("%s %s\n", max_stu.name, max_stu.id);
//    printf("%s %s\n", min_stu.name, min_stu.id);
//    return 0;
//}


/*
* 当我们验证卡拉兹猜想的时候，为了避免重复计算，可以记录下递推过程中遇到的每一个数。
例如对 n=3 进行验证的时候，我们需要计算 3、5、8、4、2、1，则当我们对 n=5、8、4、2 进行验证的时候，
就可以直接判定卡拉兹猜想的真伪，而不需要重复计算，因为这 4 个数已经在验证3的时候遇到过了，我们称 5、8、4、2 是被 3“覆盖”的数。
我们称一个数列中的某个数 n 为“关键数”，如果 n 不能被数列中的其他数字所覆盖。

现在给定一系列待验证的数字，我们只需要验证其中的几个关键数，就可以不必再重复验证余下的数字。你的任务就是找出这些关键数字，并按从大到小的顺序输出它们。

输入格式：
每个测试输入包含 1 个测试用例，第 1 行给出一个正整数 K (<100)，第 2 行给出 K 个互不相同的待验证的正整数 n (1<n≤100)的值，数字间用空格隔开。

输出格式：
每个测试用例的输出占一行，按从大到小的顺序输出关键数字。数字间用 1 个空格隔开，但一行中最后一个数字后没有空格。

输入样例：
6
3 5 6 7 8 11
输出样例：
7 6
*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//#define MAX_NUM 10000
//
//
//void makeCoveredNumbers(int n, int covered[])
//{
//    while (n != 1)
//    {
//        if (n % 2 == 0)
//        {
//            n = n / 2;
//        }
//        else
//        {
//            n = (3 * n + 1) / 2;
//        }
//        if (n <= MAX_NUM)
//        {
//            covered[n] = 1;
//        }
//    }
//}
//
//int compare(const void* a, const void* b)
//{
//    return *(int*)b - *(int*)a;
//}
//
//int main()
//{
//    int K;
//    scanf("%d", &K);
//    int numbers[K];
//    int covered[MAX_NUM + 1] = { 0 };
//
//    for (int i = 0; i < K; i++)
//    {
//        scanf("%d", &numbers[i]);
//    }
//
//    for (int i = 0; i < K; i++)
//    {
//        makeCoveredNumbers(numbers[i], covered);
//    }
//
//    int KeyNumber[K];
//    int KeyCount = 0;
//    for (int i = 0; i < K; i++)
//    {
//        if (!covered[numbers[i]])
//        {
//            KeyNumber[KeyCount++] = numbers[i];
//        }
//    }
//
//    qsort(KeyNumber, KeyCount, sizeof(int), compare);
//
//    for (int i = 0; i < KeyCount; i++)
//    {
//        printf("%d", KeyNumber[i]);
//        if (i != KeyCount - 1)
//        {
//            printf(" ");
//        }
//    }
//    return 0;
//}

/*
* 让我们用字母 B 来表示“百”、字母 S 表示“十”，用 12...n 来表示不为零的个位数字 n（<10），
换个格式来输出任一个不超过 3 位的正整数。
例如 234 应该被输出为 BBSSS1234，因为它有 2 个“百”、3 个“十”、以及个位的 4。

输入格式：
每个测试输入包含 1 个测试用例，给出正整数 n（<1000）。

输出格式：
每个测试用例的输出占一行，用规定的格式输出 n。

输入样例 1：
234
输出样例 1：
BBSSS1234
输入样例 2：
23
输出样例 2：
SS123
*/

#include<stdio.h>
#include<string.h>
//void ConvertFormat()



//int main()
//{
//	int n;
//	int a;
//	int c;
//	int b;
//
//	scanf("%d", &n);
//
//	a = n / 100;
//	for (int i = 0; i < a; i++)
//	{
//		printf("B");
//	}
//	
//	b = n / 10 % 10;
//	for (int i = 0; i < b; i++)
//	{
//		printf("S");
//	}
//	
//	c = n % 10;
//	for (int i = 1; i <= c; i++)
//	{
//		printf("%d", i);
//	}
//
//	printf("\n");
//	return 0;
//}

/*
* 让我们定义dn为：dn=Pn+1−Pn，其中Pi是第i个素数。显然有d1=1，且对于n>1有dn是偶数。
“素数对猜想”认为“存在无穷多对相邻且差为2的素数”。
现给定任意正整数N(<10^5)，请计算不超过N的满足猜想的素数对的个数。
输入格式:
输入在一行给出正整数N。
输出格式:
在一行中输出不超过N的满足猜想的素数对的个数。
输入样例:
20
输出样例:
4
*/

#include <stdio.h>
#include <stdbool.h>
#include <math.h>

//#define MAX_N 100000
//
//void sieveOfEratosthenes(bool isPrime[], int n) 
//{
//    for (int i = 2; i <= n; i++) 
//    {
//        isPrime[i] = true;
//    }
//
//    for (int p = 2; p * p <= n; p++) 
//    {
//        if (isPrime[p]) 
//        {
//            for (int i = p * p; i <= n; i += p) 
//            {
//                isPrime[i] = false;
//            }
//        }
//    }
//}
//
//int countPrimePairs(int n) 
//{
//    if (n < 2) return 0;
//
//    bool isPrime[MAX_N + 1];
//    sieveOfEratosthenes(isPrime, n);
//
//    int count = 0;
//    int prevPrime = 2; // 第一个素数
//
//    for (int i = 3; i <= n; i++) 
//    {
//        if (isPrime[i]) 
//        {
//            if (i - prevPrime == 2) 
//            {
//                count++;
//            }
//            prevPrime = i;
//        }
//    }
//
//    return count;
//}
//
//int main() 
//{
//    int N;
//    scanf("%d", &N);
//
//    printf("%d\n", countPrimePairs(N));
//
//    return 0;
//}


/*
* 一个数组A中存有N（>0）个整数，在不允许使用另外数组的前提下，
将每个整数循环向右移M（≥0）个位置，即将A中的数据由（A0​.A1⋯AN−1）变换为（AN−M⋯AN−1A0A1⋯AN−M−1）
（最后M个数循环移至最前面的M个位置）。如果需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？

输入格式:
每个输入包含一个测试用例，第1行输入N（1≤N≤100）和M（≥0）；第2行输入N个整数，之间用空格分隔。

输出格式:
在一行中输出循环右移M位以后的整数序列，之间用空格分隔，序列结尾不能有多余空格。

输入样例:
6 2
1 2 3 4 5 6
输出样例:
5 6 1 2 3 4
*/

//#include <stdio.h>
//
//void reverse(int arr[], int start, int end) 
//{
//    while (start < end) 
//    {
//        int temp = arr[start];
//        arr[start] = arr[end];//双指针
//        arr[end] = temp;
//        start++;
//        end--;
//    }
//}
//
//int main() 
//{
//    int N, M;
//    scanf("%d %d", &N, &M);
//
//    int A[N];
//    for (int i = 0; i < N; i++) 
//    {
//        scanf("%d", &A[i]);
//    }
//
//    // 处理M大于N的情况
//    M = M % N;
//
//    // 三次反转实现循环右移
//    reverse(A, 0, N - 1);      // 反转整个数组
//    reverse(A, 0, M - 1);      // 反转前M个元素
//    reverse(A, M, N - 1);      // 反转剩余元素
//
//    // 输出结果
//    for (int i = 0; i < N; i++) 
//    {
//        printf("%d", A[i]);
//        if (i != N - 1) 
//        {
//            printf(" ");
//        }
//    }
//
//    return 0;
//}

/*
给定一句英语，要求你编写程序，将句中所有单词的顺序颠倒输出。

输入格式：
测试输入包含一个测试用例，在一行内给出总长度不超过 80 的字符串。字符串由若干单词和若干空格组成，其中单词是由英文字母（大小写有区分）组成的字符串，单词之间用 1 个空格分开，输入保证句子末尾没有多余的空格。

输出格式：
每个测试用例的输出占一行，输出倒序后的句子。

输入样例：
Hello World Here I Come

输出样例：
Come I Here World Hello
*/

//#include<stdio.h>
//#include<string.h>
//
//#define MAX_LEN 81
//
//int main()
//{
//    char str[MAX_LEN];
//    fgets(str, MAX_LEN, stdin);
//
//    str[strcspn(str, "\n")] = '\0';
//
//    char words[40][20];
//    int WordCount = 0;
//
//    char* token = strtok(str, " ");
//    while (token != NULL)
//    {
//        strcpy(words[WordCount], token);
//        WordCount++;
//        token = strtok(NULL, " ");
//    }
//    for (int i = WordCount - 1; i >= 0; i--)
//    {
//        printf("%s", words[i]);
//        if (i != 0)
//        {
//            printf(" ");
//        }
//    }
//    return 0;
//}


/*
设计函数求一元多项式的导数。（注：x
n
 （n为整数）的一阶导数为nx
n−1
 。）

输入格式:
以指数递降方式输入多项式非零项系数和指数（绝对值均为不超过 1000 的整数）。数字间以空格分隔。

输出格式:
以与输入相同的格式输出导数多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。注意“零多项式”的指数和系数都是 0，但是表示为 0 0。

输入样例:
3 4 -5 2 6 1 -2 0
输出样例:
12 3 -10 1 6 0
*/


//#include<stdio.h>
//
//int main()
//{
//    int coefficient, exponent;
//    int first = 1;
//
//    while (scanf("%d %d", &coefficient, &exponent) != EOF)
//    {
//        if (exponent != 0)
//        {
//            if (!first)
//            {
//                printf(" ");
//            }
//            printf("%d %d", coefficient * exponent, exponent - 1);
//            first = 0;
//        }
//    }
//
//    if (first)
//    {
//        printf("0 0");
//    }
//    return 0;
//}




/*
给定区间 [−2
31
 ,2
31
 ] 内的 3 个整数 A、B 和 C，请判断 A+B 是否大于 C。

输入格式：
输入第 1 行给出正整数 T (≤10)，是测试用例的个数。随后给出 T 组测试用例，每组占一行，顺序给出 A、B 和 C。整数间以空格分隔。

输出格式：
对每组测试用例，在一行中输出 Case #X: true 如果 A+B>C，否则输出 Case #X: false，其中 X 是测试用例的编号（从 1 开始）。

输入样例：
4
1 2 3
2 3 4
2147483647 0 2147483646
0 -2147483648 -2147483647
输出样例：
Case #1: false
Case #2: true
Case #3: true
Case #4: false
*/


//#include<stdio.h>
//#include<string.h>
//#include<stdbool.h>
//
//bool compare(long long A, long long B, long long C)
//{
//    return (A + B) > C;
//}
//int main()
//{
//    int T;
//    scanf("%d", &T);
//    for (int i = 1; i <= T; i++)
//    {
//        long long A, B, C;
//        scanf("%lld%lld%lld", &A, &B, &C);
//        if (compare(A, B, C))
//        {
//            printf("Case #%d: true\n", i);
//        }
//        else
//        {
//            printf("Case #%d: false\n", i);
//        }
//    }
//}




/*
给定一系列正整数，请按要求对数字进行分类，并输出以下 5 个数字：

A
1
​
  = 能被 5 整除的数字中所有偶数的和；
A
2
​
  = 将被 5 除后余 1 的数字按给出顺序进行交错求和，即计算 n
1
​
 −n
2
​
 +n
3
​
 −n
4
​
 ⋯；
A
3
​
  = 被 5 除后余 2 的数字的个数；
A
4
​
  = 被 5 除后余 3 的数字的平均数，精确到小数点后 1 位；
A
5
​
  = 被 5 除后余 4 的数字中最大数字。
输入格式：
每个输入包含 1 个测试用例。每个测试用例先给出一个不超过 1000 的正整数 N，随后给出 N 个不超过 1000 的待分类的正整数。数字间以空格分隔。

输出格式：
对给定的 N 个正整数，按题目要求计算 A
1
​
 ~$$A_5$$ 并在一行中顺序输出。数字间以空格分隔，但行末不得有多余空格。

若分类之后某一类不存在数字，则在相应位置输出 N。

输入样例 1：
13 1 2 3 4 5 6 7 8 9 10 20 16 18
输出样例 1：
30 11 2 9.7 9
输入样例 2：
8 1 2 4 5 6 7 9 16
输出样例 2：
N 11 2 N 9
*/


#include<stdio.h>
#include<string.h>

int main()
{
    int N, num;
    int A1 = 0, A2 = 0, A3 = 0, A5 = 0;
    float A4 = 0.0;
    int countA4 = 0;
    int sign = 1;
    int hasA1 = 0, hasA2 = 0, hasA3 = 0, hasA4 = 0, hasA5 = 0;

    scanf("%d", &N);

    for (int i = 0; i < N; i++)
    {
        scanf("%d", &num);

        int remainder = num % 5;

        switch (remainder)
        {
        case 0:
            if (num % 2 == 0)
            {
                A1 += num;
                hasA1 = 1;
            }
            break;
        case 1:
            A2 += sign * num;
            sign *= -1;
            hasA2 = 1;
            break;
        case 2:
            A3++;
            hasA3 = 1;
            break;
        case 3:
            A4 += num;
            countA4++;
            hasA4 = 1;
            break;
        case 4:
            if (num > A5)
            {
                A5 = num;
                hasA5 = 1;
            }
            break;

        }
    }

    if (hasA1)printf("%d", A1); else printf("N");
    printf(" ");
    if (hasA2)printf("%d", A2); else printf("N");
    printf(" ");
    if (hasA3)printf("%d", A3); else printf("N");
    printf(" ");
    if (hasA4)printf("%.1f", A4 / countA4); else printf("N");
    printf(" ");
    if (hasA5)printf("%d", A5); else printf("N");

    return 0;
}